{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/usr/local/lib/python3.5/dist-packages/h5py/__init__.py:36: FutureWarning: Conversion of the second argument of issubdtype from `float` to `np.floating` is deprecated. In future, it will be treated as `np.float64 == np.dtype(float).type`.\n",
      "  from ._conv import register_converters as _register_converters\n",
      "/usr/local/lib/python3.5/dist-packages/sklearn/cross_validation.py:41: DeprecationWarning: This module was deprecated in version 0.18 in favor of the model_selection module into which all the refactored classes and functions are moved. Also note that the interface of the new CV iterators are different from that of this module. This module will be removed in 0.20.\n",
      "  \"This module will be removed in 0.20.\", DeprecationWarning)\n"
     ]
    }
   ],
   "source": [
    "from utils import *\n",
    "import tensorflow as tf\n",
    "from sklearn.cross_validation import train_test_split\n",
    "import time\n",
    "import random"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['negative', 'positive']\n",
      "10662\n",
      "10662\n"
     ]
    }
   ],
   "source": [
    "trainset = sklearn.datasets.load_files(container_path = 'data', encoding = 'UTF-8')\n",
    "trainset.data, trainset.target = separate_dataset(trainset,1.0)\n",
    "print (trainset.target_names)\n",
    "print (len(trainset.data))\n",
    "print (len(trainset.target))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_X, test_X, train_Y, test_Y = train_test_split(trainset.data, trainset.target,\n",
    "                                                    test_size = 0.2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "vocab from size: 20332\n",
      "Most common words [('film', 1453), ('movie', 1270), ('one', 727), ('like', 721), ('story', 477), ('much', 386)]\n",
      "Sample data [540, 2553, 3224, 18482, 36, 9566, 219, 150, 19, 4018] ['rock', 'destined', '21st', 'centurys', 'new', 'conan', 'hes', 'going', 'make', 'splash']\n"
     ]
    }
   ],
   "source": [
    "concat = ' '.join(trainset.data).split()\n",
    "vocabulary_size = len(list(set(concat)))\n",
    "data, count, dictionary, rev_dictionary = build_dataset(concat, vocabulary_size)\n",
    "print('vocab from size: %d'%(vocabulary_size))\n",
    "print('Most common words', count[4:10])\n",
    "print('Sample data', data[:10], [rev_dictionary[i] for i in data[:10]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "GO = dictionary['GO']\n",
    "PAD = dictionary['PAD']\n",
    "EOS = dictionary['EOS']\n",
    "UNK = dictionary['UNK']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def _pairwise_distances(embeddings, squared=False):\n",
    "    dot_product = tf.matmul(embeddings, tf.transpose(embeddings))\n",
    "    square_norm = tf.diag_part(dot_product)\n",
    "    distances = tf.expand_dims(square_norm, 1) - 2.0 * dot_product + tf.expand_dims(square_norm, 0)\n",
    "    distances = tf.maximum(distances, 0.0)\n",
    "\n",
    "    if not squared:\n",
    "        mask = tf.to_float(tf.equal(distances, 0.0))\n",
    "        distances = distances + mask * 1e-16\n",
    "        distances = tf.sqrt(distances)\n",
    "        distances = distances * (1.0 - mask)\n",
    "\n",
    "    return distances\n",
    "\n",
    "\n",
    "def _get_anchor_positive_triplet_mask(labels):\n",
    "    indices_equal = tf.cast(tf.eye(tf.shape(labels)[0]), tf.bool)\n",
    "    indices_not_equal = tf.logical_not(indices_equal)\n",
    "    labels_equal = tf.equal(tf.expand_dims(labels, 0), tf.expand_dims(labels, 1))\n",
    "    mask = tf.logical_and(indices_not_equal, labels_equal)\n",
    "\n",
    "    return mask\n",
    "\n",
    "\n",
    "def _get_anchor_negative_triplet_mask(labels):\n",
    "    labels_equal = tf.equal(tf.expand_dims(labels, 0), tf.expand_dims(labels, 1))\n",
    "    mask = tf.logical_not(labels_equal)\n",
    "\n",
    "    return mask\n",
    "\n",
    "\n",
    "def _get_triplet_mask(labels):\n",
    "    indices_equal = tf.cast(tf.eye(tf.shape(labels)[0]), tf.bool)\n",
    "    indices_not_equal = tf.logical_not(indices_equal)\n",
    "    i_not_equal_j = tf.expand_dims(indices_not_equal, 2)\n",
    "    i_not_equal_k = tf.expand_dims(indices_not_equal, 1)\n",
    "    j_not_equal_k = tf.expand_dims(indices_not_equal, 0)\n",
    "\n",
    "    distinct_indices = tf.logical_and(tf.logical_and(i_not_equal_j, i_not_equal_k), j_not_equal_k)\n",
    "\n",
    "    label_equal = tf.equal(tf.expand_dims(labels, 0), tf.expand_dims(labels, 1))\n",
    "    i_equal_j = tf.expand_dims(label_equal, 2)\n",
    "    i_equal_k = tf.expand_dims(label_equal, 1)\n",
    "\n",
    "    valid_labels = tf.logical_and(i_equal_j, tf.logical_not(i_equal_k))\n",
    "    mask = tf.logical_and(distinct_indices, valid_labels)\n",
    "\n",
    "    return mask\n",
    "\n",
    "\n",
    "def batch_all_triplet_loss(labels, embeddings, margin, squared=False):\n",
    "    pairwise_dist = _pairwise_distances(embeddings, squared=squared)\n",
    "\n",
    "    # shape (batch_size, batch_size, 1)\n",
    "    anchor_positive_dist = tf.expand_dims(pairwise_dist, 2)\n",
    "    assert anchor_positive_dist.shape[2] == 1, \"{}\".format(anchor_positive_dist.shape)\n",
    "    # shape (batch_size, 1, batch_size)\n",
    "    anchor_negative_dist = tf.expand_dims(pairwise_dist, 1)\n",
    "    assert anchor_negative_dist.shape[1] == 1, \"{}\".format(anchor_negative_dist.shape)\n",
    "\n",
    "    triplet_loss = anchor_positive_dist - anchor_negative_dist + margin\n",
    "\n",
    "    mask = _get_triplet_mask(labels)\n",
    "    mask = tf.to_float(mask)\n",
    "    triplet_loss = tf.multiply(mask, triplet_loss)\n",
    "\n",
    "    # Remove negative losses (i.e. the easy triplets)\n",
    "    triplet_loss = tf.maximum(triplet_loss, 0.0)\n",
    "\n",
    "    # Count number of positive triplets (where triplet_loss > 0)\n",
    "    valid_triplets = tf.to_float(tf.greater(triplet_loss, 1e-16))\n",
    "    num_positive_triplets = tf.reduce_sum(valid_triplets)\n",
    "    num_valid_triplets = tf.reduce_sum(mask)\n",
    "    fraction_positive_triplets = num_positive_triplets / (num_valid_triplets + 1e-16)\n",
    "\n",
    "    # Get final mean triplet loss over the positive valid triplets\n",
    "    triplet_loss = tf.reduce_sum(triplet_loss) / (num_positive_triplets + 1e-16)\n",
    "\n",
    "    return triplet_loss, fraction_positive_triplets"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Model:\n",
    "    def __init__(self, size_layer, num_layers, embedded_size,\n",
    "                 dict_size, dimension_output):\n",
    "        \n",
    "        def cells(reuse=False):\n",
    "            return tf.nn.rnn_cell.LSTMCell(size_layer,initializer=tf.orthogonal_initializer(),reuse=reuse)\n",
    "        \n",
    "        def rnn(embedded,reuse=False):\n",
    "            with tf.variable_scope('model', reuse=reuse):\n",
    "                rnn_cells = tf.nn.rnn_cell.MultiRNNCell([cells() for _ in range(num_layers)])\n",
    "                outputs, _ = tf.nn.dynamic_rnn(rnn_cells, embedded, dtype = tf.float32)\n",
    "                W = tf.get_variable('w',shape=(size_layer, dimension_output),initializer=tf.orthogonal_initializer())\n",
    "                b = tf.get_variable('b',shape=(dimension_output),initializer=tf.zeros_initializer())\n",
    "                return tf.matmul(outputs[:, -1], W) + b\n",
    "              \n",
    "        self.X = tf.placeholder(tf.int32, [None, None])\n",
    "        self.Y = tf.placeholder(tf.int32, [None])\n",
    "        embeddings = tf.Variable(tf.random_uniform([dict_size, embedded_size], -1, 1))\n",
    "        embedded = tf.nn.embedding_lookup(embeddings, self.X)\n",
    "        self.logits = rnn(embedded,False)\n",
    "        self.cost, fraction = batch_all_triplet_loss(self.Y, self.logits, margin=0.5, squared=False)\n",
    "        self.optimizer = tf.train.AdamOptimizer(1e-3).minimize(self.cost)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "size_layer = 128\n",
    "num_layers = 2\n",
    "embedded_size = 128\n",
    "dimension_output = 2\n",
    "maxlen = 50\n",
    "batch_size = 64"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "tf.reset_default_graph()\n",
    "sess = tf.InteractiveSession()\n",
    "model = Model(size_layer,num_layers,embedded_size,len(dictionary),dimension_output)\n",
    "sess.run(tf.global_variables_initializer())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_X = str_idx(train_X,dictionary,maxlen)\n",
    "test_X = str_idx(test_X,dictionary,maxlen)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch: 1, avg cost: 0.007871\n",
      "epoch: 2, avg cost: 0.007863\n",
      "epoch: 3, avg cost: 0.007891\n",
      "epoch: 4, avg cost: 0.007887\n",
      "epoch: 5, avg cost: 0.008034\n",
      "epoch: 6, avg cost: 0.007933\n",
      "epoch: 7, avg cost: 0.008077\n",
      "epoch: 8, avg cost: 0.008238\n",
      "epoch: 9, avg cost: 0.007795\n",
      "epoch: 10, avg cost: 0.007743\n"
     ]
    }
   ],
   "source": [
    "for i in range(10):\n",
    "    total_loss = 0\n",
    "    for index in range(0,len(train_X),batch_size):\n",
    "        batch_x = train_X[index:min(index+batch_size,len(train_X))]\n",
    "        batch_y = train_Y[index:min(index+batch_size,len(train_X))]\n",
    "        loss, _ = sess.run([model.cost,model.optimizer],feed_dict={model.X:batch_x,model.Y:batch_y})\n",
    "        total_loss += loss\n",
    "    total_loss /= len(train_X)\n",
    "    print('epoch: %d, avg cost: %f'%(i+1,total_loss))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(2133, 2)"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "logits_train = sess.run(model.logits,feed_dict={model.X:train_X})\n",
    "logits_test = sess.run(model.logits,feed_dict={model.X:test_X})\n",
    "logits_test.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "sns.set()\n",
    "from matplotlib import offsetbox"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f0fdf0148d0>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "ax_min = np.min(logits_test,0)\n",
    "ax_max = np.max(logits_test,0)\n",
    "ax_dist_sq = np.sum((ax_max-ax_min)**2)\n",
    "plt.figure(figsize=(8,8))\n",
    "ax = plt.subplot(111)\n",
    "shown_images = np.array([[1., 1.]])\n",
    "colors = ['b','r']\n",
    "for i in range(logits_test.shape[0]):\n",
    "    dist = np.sum((logits_test[i] - shown_images)**2, 1)\n",
    "    if np.min(dist) < 3e-4*ax_dist_sq:\n",
    "        continue\n",
    "    shown_images = np.r_[shown_images, [logits_test[i]]]\n",
    "    plt.scatter(logits_test[i,0],logits_test[i,1],c=colors[test_Y[i]])\n",
    "plt.legend(['negative','positive'])\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f0fdcffb550>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "ax_min = np.min(logits_train,0)\n",
    "ax_max = np.max(logits_train,0)\n",
    "ax_dist_sq = np.sum((ax_max-ax_min)**2)\n",
    "plt.figure(figsize=(8,8))\n",
    "ax = plt.subplot(111)\n",
    "shown_images = np.array([[1., 1.]])\n",
    "colors = ['b','r']\n",
    "for i in range(logits_train.shape[0]):\n",
    "    dist = np.sum((logits_train[i] - shown_images)**2, 1)\n",
    "    if np.min(dist) < 3e-4*ax_dist_sq:\n",
    "        continue\n",
    "    shown_images = np.r_[shown_images, [logits_train[i]]]\n",
    "    plt.scatter(logits_train[i,0],logits_train[i,1],c=colors[train_Y[i]])\n",
    "plt.legend(['negative','positive'])\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.5.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
